# -*- coding: utf-8 -*-
"""
统一文件管理器模块
负责处理文件管理相关的所有逻辑，包括UI交互和业务处理
"""

from datetime import datetime
from pathlib import Path
from PySide2.QtWidgets import (
    QTableView, QHeaderView, QMenu, QAction, QAbstractItemView,
    QMessageBox, QFileDialog, QInputDialog
)
from PySide2.QtCore import QObject, Signal, Qt, QTimer
from PySide2.QtGui import QIcon
from gglobal import logger
from ..models.filetree_model import FileTreeModel, FileInfo
from ..handlercore.language_manager import LanguageManager
from ..handlercore.file_parser import FileParser
from ..threadcore.fileoperation_thread import FileOperationWorker



class FileManager(QObject):
    """统一文件管理器类"""
    
    # 信号定义
    operation_completed_message = Signal(str, list, list)  # 通用操作完成信号 (操作类型, 成功文件列表, 失败文件列表)

    selection_changed = Signal(list)  # 选择改变
    navigation_changed = Signal(str)  # 导航路径变化
    file_list_updated = Signal(list)  # 文件列表更新信号
    operation_completed = Signal(str, bool)  # 操作完成信号 (操作类型, 是否成功)
    
    def __init__(self, parent=None):
        super().__init__(parent)
        self.parent_widget = parent
        
        # 初始化组件
        self.language_manager = LanguageManager()
        self.file_model = FileTreeModel(self.parent_widget)
        
        # 业务逻辑相关
        self._current_path = "/"
        self._client_car_thread = None
        
        # 工作线程管理
        self._current_worker = None
        self._is_operation_running = False  # 任务执行状态标志
        
        # UI组件引用（由主界面传入）
        self.file_table = None
        
        logger.info("统一文件管理器初始化完成")
    
    def _stop_current_worker(self):
        """停止当前工作线程"""
        if self._current_worker and self._current_worker.isRunning():
            # 先调用取消操作方法，发送Ctrl+C中断信号
            if hasattr(self._current_worker, 'cancel_operation'):
                self._current_worker.cancel_operation()
                logger.info("已调用工作线程的取消操作方法")
            
            # 给线程一些时间来响应取消信号
            if not self._current_worker.wait(3000):  # 等待3秒
                logger.warning("工作线程未在3秒内响应取消信号，强制终止")
                self._current_worker.terminate()
                self._current_worker.wait()
            
            self._current_worker = None
        self._is_operation_running = False  # 重置任务执行状态
    
    def _on_operation_finished(self, operation_type, success, success_files, failed_files):
        """处理操作完成信号"""
        # 重置任务执行状态
        self._is_operation_running = False
        
        # 发送操作完成信号
        self.operation_completed.emit(operation_type, success)
        
        # 发出通用操作完成信号
        self.operation_completed_message.emit(operation_type, success_files, failed_files)
        
        # 如果是修改文件系统的操作，刷新文件列表
        if operation_type in ["upload", "delete", "extract", "compress"]:
            QTimer.singleShot(1000, self.refresh_file_list)
    
    def set_ui_components(self, file_table):
        """设置UI组件引用"""
        self.file_table = file_table
        
        # 设置文件模型
        self.file_table.setModel(self.file_model)
        
        # 设置表格属性
        self.file_table.setSelectionBehavior(QAbstractItemView.SelectRows)
        self.file_table.setSelectionMode(QAbstractItemView.ExtendedSelection)
        self.file_table.setAlternatingRowColors(True)
        self.file_table.setSortingEnabled(False)  # 禁用内置排序，使用自定义排序
        self.file_table.setDragDropMode(QAbstractItemView.DropOnly)
        self.file_table.setAcceptDrops(True)
        
        # 设置列宽
        header = self.file_table.horizontalHeader()
        header.setStretchLastSection(True)
        header.resizeSection(0, 450)  # 名称列
        header.resizeSection(1, 100)  # 大小列
        header.resizeSection(2, 150)  # 时间列
        header.resizeSection(3, 100)  # 权限列
        
        # 设置表头排序功能
        header.setSortIndicatorShown(True)
        header.setSectionsClickable(True)
        
        # 设置行高
        self.file_table.verticalHeader().setDefaultSectionSize(28)
        self.file_table.verticalHeader().setVisible(False)
        
        # 连接信号
        self.setup_table_connections()
        
    def setup_table_connections(self):
        """设置表格信号连接"""
        if not self.file_table:
            return
            
        # 文件表格信号连接
        self.file_table.doubleClicked.connect(self.on_file_double_clicked)
        self.file_table.setContextMenuPolicy(Qt.CustomContextMenu)
        self.file_table.customContextMenuRequested.connect(self.show_context_menu)
        
        # 表头排序信号连接
        header = self.file_table.horizontalHeader()
        header.sectionClicked.connect(self.on_header_clicked)
        
        # 文件模型信号连接
        self.file_model.selection_changed.connect(self.on_selection_changed)
        
    def set_client_thread(self, client_thread):
        """设置客户端连接线程
        
        参数:
            client_thread: ClientCarThread实例或None
        """
        # 如果之前有客户端线程，先断开信号连接
        if self._client_car_thread:
            try:
                # 断开信号连接，先尝试具体槽函数
                if hasattr(self._client_car_thread, 'file_list_updated'):
                    try:
                        self._client_car_thread.file_list_updated.disconnect(self.handle_file_list_updated)
                    except (TypeError, RuntimeError):
                        # 如果具体槽函数断开失败，尝试断开所有连接
                        self._client_car_thread.file_list_updated.disconnect()
                        
                if hasattr(self._client_car_thread, 'current_path_changed'):
                    try:
                        self._client_car_thread.current_path_changed.disconnect(self._on_current_path_changed)
                    except (TypeError, RuntimeError):
                        # 如果具体槽函数断开失败，尝试断开所有连接
                        self._client_car_thread.current_path_changed.disconnect()
                        
                logger.info("已断开之前客户端线程的信号连接")
            except Exception as e:
                logger.warning(f"断开客户端线程信号连接时发生异常: {e}")
        
        self._client_car_thread = client_thread
        if client_thread:
            # 连接客户端线程的信号
            client_thread.file_list_updated.connect(self.handle_file_list_updated)
            client_thread.current_path_changed.connect(self._on_current_path_changed)
            logger.info("客户端线程已设置并连接信号")
        else:
            logger.info("客户端线程已清除")
    
    def parse_file_list(self, file_list_data):
        """解析文件列表数据
        
        参数:
            file_list_data: 文件列表原始数据
            
        返回:
            list: FileInfo对象列表
        """
        # 使用统一的文件解析器
        files = FileParser.parse_ls_output(file_list_data, self._current_path)
        return FileParser.filter_valid_files(files)
    
    def on_file_double_clicked(self, index):
        """文件双击处理"""
        file_info = self.file_model.get_file_info(index.row())
        if not file_info:
            return
            
        if not self._client_car_thread:
            logger.error("客户端线程未设置")
            return
            
        if file_info.is_parent:
            # 返回上级目录 - 异步执行cd ..
            logger.info("双击返回上级目录，异步执行cd ..")
            self._navigate_to_directory("..")
        elif file_info.is_directory:
            # 进入子目录 - 异步执行cd 目录名
            logger.info(f"双击进入子目录: {file_info.name}，异步执行cd {file_info.name}")
            self._navigate_to_directory(file_info.name)
        else:
            # 文件操作（可以是预览或下载）
            logger.info(f"双击文件: {file_info.name}")
    
    def _check_operation_status(self):
        """检查是否有任务正在执行
        
        返回:
            bool: True表示可以执行新任务，False表示有任务正在执行
        """
        if self._is_operation_running:
            self.operation_completed.emit("perform_the_operation", False)
            return False
        return True
    
    def _navigate_to_directory(self, directory_path):
        """异步导航到指定目录
        
        参数:
            directory_path: 目录路径
        """
        # 检查是否有任务正在执行
        if not self._check_operation_status():
            return
            
        if not self._client_car_thread:
            logger.error("客户端线程未设置")
            return
        
        # 停止当前工作线程
        self._stop_current_worker()
        
        # 设置任务执行状态
        self._is_operation_running = True
        
        # 创建并启动工作线程
        self._current_worker = FileOperationWorker("change_directory", self._client_car_thread, directory_path)
        self._current_worker.operation_finished.connect(self._on_change_directory_finished)
        self._current_worker.start()
            
    
    def on_header_clicked(self, logical_index):
        """表头点击处理 - 实现排序功能"""
        # 获取当前排序信息
        current_sort_column, current_sort_order = self.file_model.get_sort_info()
        logger.debug(f"当前排序状态: 列{current_sort_column}, {'升序' if current_sort_order == Qt.AscendingOrder else '降序'}")
        
        # 确定新的排序顺序
        if current_sort_column == logical_index:
            # 如果点击的是当前排序列，切换排序顺序
            new_order = Qt.DescendingOrder if current_sort_order == Qt.AscendingOrder else Qt.AscendingOrder
        else:
            # 如果点击的是新列，默认升序
            new_order = Qt.AscendingOrder
            
        logger.debug(f"新排序设置: 列{logical_index}, {'升序' if new_order == Qt.AscendingOrder else '降序'}")
        
        # 执行排序
        self.file_model.sort(logical_index, new_order)
        
        # 更新表头排序指示器
        header = self.file_table.horizontalHeader()
        header.setSortIndicator(logical_index, new_order)
        
        logger.info(f"表头点击排序: 列{logical_index}, {'升序' if new_order == Qt.AscendingOrder else '降序'}")
        
    def show_context_menu(self, position):
        """显示右键菜单"""
        if not self.file_table:
            return
            
        index = self.file_table.indexAt(position)
        
        # 获取当前选中的行
        selected_indexes = self.file_table.selectionModel().selectedRows()
        selected_files = []
        
        # 如果有选中的文件，获取文件信息
        if selected_indexes:
            for idx in selected_indexes:
                file_info = self.file_model.get_file_info(idx.row())
                if file_info and not file_info.is_parent:  # 排除返回上级目录项
                    selected_files.append(file_info)
        
        # 创建右键菜单
        menu = QMenu(self.parent_widget)
        
        # 如果有选中文件，显示文件操作菜单
        if selected_files:
            # 下载文件
            download_text = self.language_manager.get_text("download_file_action", "下载文件")
            download_action = QAction(download_text, self.parent_widget)
            download_action.setIcon(QIcon(":/icon/download.svg"))
            download_action.triggered.connect(lambda: self.download_files(selected_files))
            menu.addAction(download_action)
            
            # 删除文件
            delete_text = self.language_manager.get_text("delete_file_action", "删除文件")
            delete_action = QAction(delete_text, self.parent_widget)
            delete_action.setIcon(QIcon(":/icon/delfile.svg"))
            delete_action.triggered.connect(lambda: self.delete_files(selected_files))
            menu.addAction(delete_action)
            
            # 解压文件（仅对压缩文件显示）
            has_archive = any(file_info.name.endswith(('.zip', '.tar', '.gz', '.tar.gz')) 
                             for file_info in selected_files)
            if has_archive:
                extract_text = self.language_manager.get_text("extract_file_action", "解压文件")
                extract_action = QAction(extract_text, self.parent_widget)
                extract_action.setIcon(QIcon(":/icon/archive.svg"))
                extract_action.triggered.connect(lambda: self.extract_files(selected_files))
                menu.addAction(extract_action)
                
            # 压缩文件
            compress_text = self.language_manager.get_text("compress_file_action", "压缩文件")
            compress_action = QAction(compress_text, self.parent_widget)
            compress_action.setIcon(QIcon(":/icon/zipfile.svg"))
            compress_action.triggered.connect(lambda: self.compress_files(selected_files))
            menu.addAction(compress_action)
            
            # 添加分隔符
            menu.addSeparator()
        
        # 上传文件（无论是否选中文件都显示）
        upload_text = self.language_manager.get_text("upload_file_action", "上传文件")
        upload_action = QAction(upload_text, self.parent_widget)
        upload_action.setIcon(QIcon(":/icon/pushfile.svg"))
        upload_action.triggered.connect(lambda: self._show_upload_dialog())
        menu.addAction(upload_action)
        
        # 刷新文件列表（无论是否选中文件都显示）
        if selected_files:  # 如果有选中文件，添加分隔符
            menu.addSeparator()
        refresh_text = self.language_manager.get_text("refresh_file_list", "刷新")
        refresh_action = QAction(refresh_text, self.parent_widget)
        refresh_action.setIcon(QIcon(":/icon/refresh.svg"))
        refresh_action.triggered.connect(lambda: self.refresh_file_list())
        menu.addAction(refresh_action)
            
        # 显示菜单
        menu.exec_(self.file_table.mapToGlobal(position))
        
    def download_files(self, files):
        """下载文件
        
        参数:
            files: FileInfo对象列表
        """
        # 检查是否有任务正在执行
        if not self._check_operation_status():
            return False
            
        if not files:
            self._show_info_message("select_files_info", "请先选择要下载的文件")
            return False
            
        if not self._client_car_thread:
            self._show_warning_message("connection_required_warning", "请先连接到远程设备")
            return False
        
        # 选择下载目录
        download_dir = QFileDialog.getExistingDirectory(
            self.parent_widget,
            self.language_manager.get_text("select_download_dir", "选择下载目录"),
            str(Path.home() / "Downloads")
        )
        
        if not download_dir:
            return False
        
        # 停止当前工作线程
        self._stop_current_worker()
        
        # 设置任务执行状态
        self._is_operation_running = True
        
        # 创建并启动工作线程
        self._current_worker = FileOperationWorker("download", self._client_car_thread, files, download_dir, self._current_path)
        self._current_worker.operation_finished.connect(self._on_operation_finished)
        self._current_worker.start()
        
        return True
    
    def delete_files(self, files):
        """删除文件
        
        参数:
            files: FileInfo对象列表
        """
        # 检查是否有任务正在执行
        if not self._check_operation_status():
            return False
            
        if not files:
            self._show_info_message("select_files_info", "请先选择要删除的文件")
            return False
            
        if not self._client_car_thread:
            self._show_warning_message("connection_required_warning", "请先连接到远程设备")
            return False
        
        # 确认删除
        if not self._confirm_delete(files):
            return False
        
        # 停止当前工作线程
        self._stop_current_worker()
        
        # 设置任务执行状态
        self._is_operation_running = True
        
        # 创建并启动工作线程
        self._current_worker = FileOperationWorker("delete", self._client_car_thread, files)
        self._current_worker.operation_finished.connect(self._on_operation_finished)
        self._current_worker.start()
        
        return True
    
    def extract_files(self, files):
        """解压文件
        
        参数:
            files: FileInfo对象列表
        """
        # 检查是否有任务正在执行
        if not self._check_operation_status():
            return False
            
        if not self._client_car_thread:
            self._show_warning_message("connection_required_warning", "请先连接到远程设备")
            return False
        
        # 筛选压缩文件
        archive_files = [f for f in files if f.name.endswith(('.zip', '.tar', '.gz', '.tar.gz'))]
        if not archive_files:
            self._show_info_message("no_archive_files", "没有可解压的文件")
            return False
        
        # 停止当前工作线程
        self._stop_current_worker()
        
        # 设置任务执行状态
        self._is_operation_running = True
        
        # 创建并启动工作线程
        self._current_worker = FileOperationWorker("extract", self._client_car_thread, archive_files)
        self._current_worker.operation_finished.connect(self._on_operation_finished)
        self._current_worker.start()
        
        return True
    
    def compress_files(self, files):
        """压缩文件
        
        参数:
            files: FileInfo对象列表
        """
        # 检查是否有任务正在执行
        if not self._check_operation_status():
            return False
            
        if not self._client_car_thread:
            self._show_warning_message("connection_required_warning", "请先连接到远程设备")
            return False
        
        if not files:
            return False
        
        # 选择压缩格式
        format_choice = self._select_compress_format()
        if not format_choice:
            return False
        
        # 停止当前工作线程
        self._stop_current_worker()
        
        # 设置任务执行状态
        self._is_operation_running = True
        
        # 处理文件路径，去除当前路径前缀以避免压缩文件嵌套多层路径
        processed_files = []
        for file_info in files:
            # 创建文件信息副本
            processed_file = type('FileInfo', (), {})()
            processed_file.__dict__.update(file_info.__dict__)
            
            # 如果文件名包含当前路径，则去除当前路径前缀
            if self._current_path and file_info.name.startswith(self._current_path):
                # 去除当前路径前缀，保留相对路径
                relative_name = file_info.name[len(self._current_path):]
                # 去除开头的路径分隔符
                if relative_name.startswith('/') or relative_name.startswith('\\'):
                    relative_name = relative_name[1:]
                processed_file.name = relative_name
                logger.info(f"处理文件路径: {file_info.name} -> {processed_file.name}")
            else:
                processed_file.name = file_info.name
                
            processed_files.append(processed_file)
        # 创建并启动工作线程
        self._current_worker = FileOperationWorker("compress", self._client_car_thread, processed_files, format_choice)
        self._current_worker.operation_finished.connect(self._on_operation_finished)
        self._current_worker.start()
        
        return True
    
    def upload_files(self, local_files):
        """上传文件
        
        参数:
            local_files: 本地文件路径列表
        """
        # 检查是否有任务正在执行
        if not self._check_operation_status():
            return False
            
        if not self._client_car_thread:
            self._show_warning_message("connection_required_warning", "请先连接到远程设备")
            return False
        
        # 停止当前工作线程
        self._stop_current_worker()
        
        # 设置任务执行状态
        self._is_operation_running = True
        
        # 创建并启动工作线程
        self._current_worker = FileOperationWorker("upload", self._client_car_thread, local_files)
        self._current_worker.operation_finished.connect(self._on_operation_finished)
        self._current_worker.start()
        
        return True
    
    def refresh_file_list(self):
        """刷新文件列表"""
        # 检查是否有任务正在执行
        if not self._check_operation_status():
            return False
            
        if not self._client_car_thread:
            logger.warning("客户端线程未连接，无法刷新文件列表")
            return False
        
        # 停止当前工作线程
        self._stop_current_worker()
        
        # 设置任务执行状态
        self._is_operation_running = True
        
        # 创建并启动工作线程
        self._current_worker = FileOperationWorker("list_directory", self._client_car_thread)
        self._current_worker.operation_finished.connect(self._on_list_directory_finished)
        self._current_worker.start()
        return True
    
    def _on_list_directory_finished(self, operation_type, success, success_files, failed_files):
        """处理目录列表操作完成"""
        # 重置任务执行状态
        self._is_operation_running = False
        
        if success:
            # 获取最新的文件列表并发出信号
            files = self._client_car_thread.get_current_file_list() if hasattr(self._client_car_thread, 'get_current_file_list') else []
            self.file_list_updated.emit(files)
            logger.info(f"文件列表已刷新，共 {len(files)} 个文件")
        else:
            logger.error("刷新文件列表失败")
    
    def get_current_path(self):
        """获取当前路径"""
        return self._current_path
    
    def set_current_path(self, path):
        """设置当前路径"""
        self._current_path = path
        self.navigation_changed.emit(path)
    
    def get_selected_files(self):
        """获取当前选中的文件"""
        if not self.file_table:
            return []
            
        selected_indexes = self.file_table.selectionModel().selectedRows()
        selected_files = []
        
        for idx in selected_indexes:
            file_info = self.file_model.get_file_info(idx.row())
            if file_info and not file_info.is_parent:  # 排除返回上级目录项
                selected_files.append(file_info)
                
        return selected_files
        
    def get_file_model(self):
        """获取文件模型"""
        return self.file_model
        
    def set_files(self, files, current_path):
        """设置文件列表"""
        self.file_model.set_files(files, current_path)
        
    def clear_files(self):
        """清空文件列表"""
        self.file_model.clear()
        
    def get_sort_info(self):
        """获取排序信息"""
        return self.file_model.get_sort_info()
        
    def sort_files(self, column, order):
        """排序文件"""
        self.file_model.sort(column, order)
        
        # 更新表头排序指示器
        if self.file_table:
            header = self.file_table.horizontalHeader()
            header.setSortIndicator(column, order)
    
    def on_selection_changed(self, selected_files):
        """选择改变处理"""
        logger.debug(f"选择了 {len(selected_files)} 个文件")
        # 转发信号
        self.selection_changed.emit(selected_files)
    
    # def _on_file_list_updated(self, file_list):
    #     """文件列表更新处理"""
    #     parsed_files = self.parse_file_list(file_list)
    #     self.file_list_updated.emit(parsed_files)
        
    #     # 直接更新文件模型
    #     if isinstance(parsed_files, list) and parsed_files:
    #         self.file_model.set_files(parsed_files, self._current_path)
    #         logger.info(f"文件列表已更新，共 {len(parsed_files)} 个文件")
    
    def handle_file_list_updated(self, files):
        """处理文件列表更新 - 从UI层调用"""
        # 直接使用FileManager解析后的文件列表
        if isinstance(files, list) and files:
            # 如果是FileInfo对象列表，直接使用
            if hasattr(files[0], 'name'):
                self.set_files(files, self.get_current_path())
                logger.info(f"文件列表已更新，共 {len(files)} 个文件，当前路径: {self.get_current_path()}")
            else:
                # 如果是原始数据，委托给FileManager解析
                parsed_files = self.parse_file_list(files)
                self.set_files(parsed_files, self.get_current_path())
                logger.info(f"文件列表已更新，共 {len(parsed_files)} 个文件")
    
    def handle_header_clicked(self, logical_index):
        """处理表头点击 - 实现排序功能"""
        if not self.file_table:
            return
            
        # 获取当前排序信息
        current_sort_column, current_sort_order = self.file_model.get_sort_info()
        logger.debug(f"当前排序状态: 列{current_sort_column}, {'升序' if current_sort_order == Qt.AscendingOrder else '降序'}")
        
        # 确定新的排序顺序
        if current_sort_column == logical_index:
            # 如果点击的是当前排序列，切换排序顺序
            new_order = Qt.DescendingOrder if current_sort_order == Qt.AscendingOrder else Qt.AscendingOrder
        else:
            # 如果点击的是新列，默认升序
            new_order = Qt.AscendingOrder
            
        logger.debug(f"新排序设置: 列{logical_index}, {'升序' if new_order == Qt.AscendingOrder else '降序'}")
        
        # 执行排序
        self.sort_files(logical_index, new_order)
        
        # 更新表头排序指示器
        header = self.file_table.horizontalHeader()
        header.setSortIndicator(logical_index, new_order)
        
        logger.info(f"表头点击排序: 列{logical_index}, {'升序' if new_order == Qt.AscendingOrder else '降序'}")
    
    def _on_current_path_changed(self, new_path):
        """当前路径变化处理"""
        logger.info(f"接收到路径变化信号: {new_path}")
        old_path = self._current_path
        self._current_path = new_path
        logger.info(f"文件管理器路径已同步: {old_path} -> {new_path}")
        self.navigation_changed.emit(new_path)
    
    def _confirm_delete(self, files):
        """确认删除对话框
        
        参数:
            files: 要删除的文件列表
            
        返回:
            bool: 用户是否确认删除
        """
        confirm_title = self.language_manager.get_text("confirm_delete_title", "确认删除")
        confirm_msg = self.language_manager.get_text("confirm_delete_message", "确定要删除选中的 {count} 个文件吗？\n此操作不可撤销！")
        confirm_msg = confirm_msg.format(count=len(files))
        
        reply = QMessageBox.question(
            self.parent_widget, confirm_title, confirm_msg,
            QMessageBox.Yes | QMessageBox.No,
            QMessageBox.No
        )
        
        return reply == QMessageBox.Yes
    
    def _select_compress_format(self):
        """选择压缩格式对话框
        
        返回:
            str: 选择的压缩格式，取消返回None
        """
        formats = ["tar.gz", "zip", "tar"]
        format_choice, ok = QInputDialog.getItem(
            self.parent_widget,
            self.language_manager.get_text("select_compress_format", "选择压缩格式"),
            self.language_manager.get_text("compress_format_label", "压缩格式:"),
            formats,
            0,
            False
        )
        
        return format_choice if ok else None
    
    def _show_warning_message(self, key, default_text):
        """显示警告消息"""
        warning_title = self.language_manager.get_text("warning_title", "警告")
        warning_msg = self.language_manager.get_text(key, default_text)
        QMessageBox.warning(self.parent_widget, warning_title, warning_msg)
    
    def _show_info_message(self, key, default_text):
        """显示信息消息"""
        info_title = self.language_manager.get_text("info_title", "提示")
        info_msg = self.language_manager.get_text(key, default_text)
        QMessageBox.information(self.parent_widget, info_title, info_msg)
    
    def navigate_to_path(self, path):
        """导航到指定路径"""
        # 检查是否有任务正在执行
        if not self._check_operation_status():
            return False
            
        if not self._client_car_thread:
            return False
        
        # 停止当前工作线程
        self._stop_current_worker()
        
        # 设置任务执行状态
        self._is_operation_running = True
        
        # 创建并启动工作线程
        self._current_worker = FileOperationWorker("change_directory", self._client_car_thread, path)
        self._current_worker.operation_finished.connect(self._on_change_directory_finished)
        self._current_worker.start()
        
        return True
    
    def _on_change_directory_finished(self, operation_type, success, success_files, failed_files):
        """处理目录切换完成"""
        # 重置任务执行状态
        self._is_operation_running = False
        
        if success:
            # 获取当前路径并发出导航变化信号
            current_path = self._client_car_thread.get_current_remote_path() if hasattr(self._client_car_thread, 'get_current_remote_path') else self._current_path
            self._current_path = current_path
            self.navigation_changed.emit(current_path)
            logger.info(f"成功切换到路径: {current_path}")
            
            # 切换目录后刷新文件列表
            QTimer.singleShot(500, self.refresh_file_list)
        else:
             logger.error(f"切换目录失败: {failed_files}")
             self.operation_completed.emit("change_directory", False)
    
    def _show_upload_dialog(self):
        """显示上传文件对话框"""
        if not self._client_car_thread:
            self._show_warning_message("connection_required_warning", "请先连接到远程设备")
            return False
        
        # 选择要上传的文件
        upload_title = self.language_manager.get_text("select_upload_files", "选择要上传的文件")
        file_filter = self.language_manager.get_text("all_files_filter", "所有文件 (*.*)")
        
        local_files, _ = QFileDialog.getOpenFileNames(
            self.parent_widget,
            upload_title,
            str(Path.home()),
            file_filter
        )
        
        if not local_files:
            return False
        
        # 调用上传方法
        return self.upload_files(local_files)
    
    def __del__(self):
        """析构函数，清理工作线程"""
        self._stop_current_worker()